home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / mac / developm / source / ncsat.cpt / Telnet2.5 final / tek / tekrgmac.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-07-07  |  11.8 KB  |  680 lines
  1. #ifdef lint
  2. static char *SCCSid = "%W%    (NCSA)    %G%";
  3. #endif
  4.  
  5. /*
  6.  
  7. rgmac.c by Gaige B. Paulsen
  8.   spawned from rgp.c by Aaron Contorer for NCSA
  9. Copyright 1987, board of trustees, University of Illinois
  10.  
  11. Routines for Macintosh Window output.  
  12.  
  13. */
  14.  
  15.  
  16. /* 
  17.  *    Include files 
  18.  */
  19.  
  20. #include <stdio.h>
  21. #include <String.h>
  22.  
  23. #include <Controls.h>
  24. #include <Dialogs.h>
  25. #include <Events.h>
  26. #include <OSutils.h>
  27. #include <Packages.h>
  28. #include <Quickdraw.h>
  29. #include <Windows.h>
  30. #include <Memory.h>
  31.  
  32. #ifdef MPW
  33. #include "mpw.h"
  34. #endif MPW
  35. #include "configrec.h"
  36. #include "maclook.h"
  37. #include "whatami.h"
  38. #include "vgtek.h"
  39. #include "tools.h"
  40. #include "util.h"
  41. #include "rsmac.h"
  42.  
  43. #define TRUE 1
  44. #define FALSE 0
  45.  
  46. #define SPLASH_SQUARED    4
  47.  
  48. /*
  49.  * display structure....
  50.  */
  51.  
  52. struct RGMwindows {
  53. GrafPtr
  54.     wind;
  55. int
  56.     xorigin,
  57.     yorigin,
  58.     xscale,
  59.     yscale,
  60.     vg,
  61.     vs,
  62.     inuse,
  63.     ingin;
  64. unsigned char
  65.     *name;
  66. int
  67.     width,
  68.     height;
  69. ControlHandle
  70.     zoom,
  71.     vert,
  72.     horiz;
  73.     } *RGMwind[ MAXWIND ];    /* BYU - changed from an array of structure to an array of pointers */
  74.  
  75. long RGMlastclick;
  76.  
  77. int RGMcolor[]=
  78.     { 30,            /* black */
  79.       33,            /* white */
  80.       205,            /* red */
  81.       341,            /* green */
  82.       409,            /* blue */
  83.       273,            /* cyan */
  84.       137,            /* magenta */
  85.       69            /* yellow */
  86.       };
  87.  
  88.  
  89. char *macname = "Macintosh Windows";
  90.  
  91. int RGsetwind
  92.   (
  93.     int dnum
  94.   )
  95. {
  96.  
  97.     if (dnum<0 || dnum>=MAXWIND) return(-1);
  98.  
  99.     if (!RGMwind[dnum]->inuse) return(-1);
  100.  
  101.     SetPort( RGMwind[dnum]->wind);
  102.     return(0);
  103. }
  104.  
  105. RGMgin(w)
  106. {
  107.     if (RGsetwind(w)) return(-1);
  108.  
  109.     setgraphcurs();
  110.     RGMwind[w]->ingin=1;
  111. }
  112.  
  113. RGMoutfunc(f)
  114.     int (*f)();
  115.   {
  116. #pragma unused(f)
  117.   }
  118.  
  119.  
  120. RGMpencolor(w, color)
  121. {
  122.     if (RGsetwind(w) ) return(-1);
  123.  
  124.     ForeColor((long) RGMcolor[color] );
  125. }
  126.  
  127. RGMclrscr(w)
  128. {
  129.     if (RGsetwind(w) ) return(-1);
  130.  
  131.     PaintRect(&RGMwind[w]->wind->portRect);
  132. }
  133.  
  134. RGMclose(w)
  135. {
  136.     if (RGsetwind(w) ) return(-1);
  137.  
  138.     DisposeWindow(RGMwind[w]->wind);
  139.     RGMwind[w]->inuse  = FALSE;
  140.  
  141. }
  142.  
  143. RGMpoint(w,x,y)
  144. {
  145.     if (RGsetwind(w) ) return(-1);
  146.  
  147.     MoveTo(x,y);
  148.     LineTo(x,y);
  149. } 
  150.  
  151. RGMdrawline(w,x0,y0,x1,y1)
  152. int w,x0,y0,x1,y1;
  153. {
  154.     if (RGsetwind(w) ) return(-1);
  155.  
  156.     x0 = (int) ((long) x0 * RGMwind[w]->width / INXMAX);
  157.     y0 = RGMwind[w]->height - (int) ((long) y0 * RGMwind[w]->height / INYMAX);
  158.     x1 = (int) ((long) x1 * RGMwind[w]->width/INXMAX);
  159.     y1 = RGMwind[w]->height - (int) ((long) y1 * RGMwind[w]->height / INYMAX);
  160.  
  161.     MoveTo(x0,y0);
  162.     LineTo(x1,y1);
  163. }
  164.  
  165. RGMpagedone(w)
  166.   {
  167. #pragma unused(w)
  168.   }
  169.  
  170. RGMdataline(w,data,count)
  171.   {
  172. #pragma unused(w, data, count)
  173.   }
  174.  
  175.  
  176. RGMcharmode(w,rotation,size)
  177.   {
  178. #pragma unused(w, rotation, size)
  179.   }
  180.  
  181. RGMshowcur()
  182.   {
  183.   }
  184.  
  185. RGMlockcur()
  186.   {
  187.   }
  188.  
  189. RGMhidecur()
  190.   {
  191.   }
  192.  
  193. RGMbell(w)
  194.   {
  195. #pragma unused(w)
  196.   }
  197.  
  198. RGMuncover(w)
  199.   {
  200. #pragma unused(w)
  201.   }
  202.  
  203. char *RGMdevname() {
  204.     return(macname);
  205. }
  206.  
  207. int RGMalloc()            /* BYU - allocate this structure to save global space */
  208. {                    /* BYU */
  209.     int i;                            /* BYU */
  210.     for(i=0; i<MAXWIND; i++) {        /* BYU */
  211.         RGMwind[i] = (struct RGMwindows *) NewPtr((long) sizeof(struct RGMwindows));    /* BYU */
  212.         if (RGMwind[i]) {                        /* BYU */
  213.             RGMwind[i]->wind = (GrafPtr) 0;        /* BYU */
  214.             RGMwind[i]->vg = -1;                /* BYU - necessary */
  215.             RGMwind[i]->vs = -1;                /* BYU */
  216.             RGMwind[i]->inuse = 0;                /* BYU - necessary */
  217.         } else                                     /* BYU */
  218.             return -1;                /* BYU - insufficient memory */
  219.     }                        /* BYU */
  220.     return(0);        /* BYU */
  221. }                    /* BYU */
  222.  
  223. RGMinit()
  224. {
  225.     int i;
  226.     for (i = 0; i < MAXWIND; i++)
  227.         RGMwind[i]->inuse = 0;
  228. }
  229.  
  230. RGMinfo(w,v,a,b,c,d)
  231.     int w,a,b,c,d,v;
  232.   {
  233. #pragma unused(a, b, c, d)
  234.     RGMwind[w]->vg=v;
  235.   }
  236.  
  237. RGMgmode()
  238. {}
  239.  
  240. RGMtmode()
  241. {}
  242.  
  243. RGMnewwin()
  244. {
  245. int i = 0;
  246. int maxdim =0;
  247.  
  248.     while ((i < MAXWIND) && (RGMwind[i]->inuse)) i++;
  249.  
  250.     if (i >= MAXWIND) return(-1);
  251.  
  252.     RGMwind[i]->wind = GetNewWindow(256, (Ptr) 0L, (WindowPtr) -1L);
  253.  
  254.     if (RGMwind[i]->wind == 0L) return(-1);
  255.     if (qd.screenBits.bounds.bottom > 400)
  256.         {
  257.         SizeWindow(RGMwind[i]->wind, 400, 300, FALSE);
  258.         maxdim = 400;
  259.         }
  260.     else
  261.         maxdim = 342;
  262.  
  263.     RGMwind[i]->vg = -1;                /* BYU */
  264.     RGMwind[i]->vs = -1;                /* BYU */
  265.     RGMwind[i]->xorigin = 0;
  266.     RGMwind[i]->yorigin = 0;
  267.     RGMwind[i]->xscale  = WINXMAX;        /* BYU 2.4.7 - added the "W" */
  268.     RGMwind[i]->yscale  = WINYMAX;        /* BYU 2.4.7 - added the "W" */
  269.     RGMwind[i]->width   = maxdim;            /* BYU 2.4.7 - was 256 */
  270.     RGMwind[i]->height  = (maxdim*3)/4;            /* BYU 2.4.7 - was 342 */
  271.     RGMwind[i]->inuse   = TRUE;
  272.     RGMwind[i]->ingin   = 0;
  273.  
  274.     ValidRect(&RGMwind[i]->wind->portRect);
  275.  
  276.     return(i);
  277. }
  278.  
  279. int RGfindbyVG
  280.   (
  281.     int vg
  282.   )
  283. {
  284. int i = 0;
  285.  
  286.     while ((i < MAXWIND) && ((!RGMwind[i]->inuse) || (RGMwind[i]->vg != vg)))
  287.         i++;
  288.     if (i >= MAXWIND) return(-1);
  289.     return(i);
  290. }
  291.  
  292. int RGattach
  293.   (
  294.     int vg,
  295.     int virt,
  296.     char *name
  297.   )
  298. {
  299. int        dnum;
  300. long    time;
  301. char    myname[256],ts[256];
  302.  
  303.     if ((dnum = RGfindbyVG(vg)) < 0) return(-1);
  304.  
  305. sprintf(ts,"RGattach: vg = %d, vs = %d, \042%s\042);  dnum = %d",    /* BYU */
  306.     vg,virt,name,dnum);                                                /* BYU */
  307. putln(ts);
  308.  
  309.     RGMwind[dnum]->vs = virt;
  310.     RGMwind[dnum]->name = (char *) NewPtr((long) 256);    /* BYU */
  311.  
  312.     if (RGMwind[dnum]->name == 0L) return(-2);
  313.  
  314. #if 1                                    /* BYU */
  315.     myname[0] = 165;                    /* BYU - the "dot" */
  316.     strncpy(&myname[1],name,254);        /* BYU - don't copy too much */
  317. #else                                    /* BYU */
  318.     RGMwind[dnum]->name[0] = 165;
  319.     strncpy(&RGMwind[dnum]->name[1],name,255);
  320. #endif                                    /* BYU */
  321.  
  322.     GetDateTime((unsigned long *) &time);
  323.     iutimestring(time,FALSE,ts);                    /* Put time in the temp string */
  324.  
  325. #if 1                                    /* BYU */
  326.     strncat(myname,"  ",4);                /* BYU - Space, please */
  327.     strncat(myname,ts,64);                /* BYU - Place the time string at the end */
  328.     strcpy(RGMwind[dnum]->name,myname);    /* BYU */
  329. #else                                    /* BYU */
  330.     strncat(RGMwind[dnum]->name,"  ",255);            /* Space, please */
  331.     strncat(RGMwind[dnum]->name,ts,255);            /* Place the time string at the end */
  332. #endif
  333.  
  334. #if 1                                            /* BYU */
  335.     if (RGMwind[dnum]->wind != (GrafPtr) 0)     /* BYU */
  336.         setwtitle(RGMwind[dnum]->wind,myname);    /* BYU */
  337. #else                                            /* BYU */
  338.     setwtitle(RGMwind[dnum]->wind,RGMwind[dnum]->name);
  339. #endif                                            /* BYU */
  340.     return(0);
  341. }
  342.  
  343.  
  344. int RGdetach        /* BYU */
  345.   (
  346.     int vg            /* BYU */
  347.   )
  348. {
  349. int dnum;            /* BYU */
  350. char    temp[64];
  351.  
  352.     if ((dnum = RGfindbyVG(vg)) < 0) return(-1);        /* BYU */
  353.     if (dnum >= MAXWIND)  return(-1);                    /* BYU */
  354.  
  355. sprintf(temp,"RGdetach: dnum = %d, vg = %d, vs = %d, Wind = %lx",    /* BYU */
  356.     dnum,RGMwind[dnum]->vg,RGMwind[dnum]->vs,RGMwind[dnum]->wind);    /* BYU */
  357. putln(temp);
  358.     if (RGMwind[dnum]->vs != -1) {                 /* BYU */
  359.         if (RGMwind[dnum]->wind != (GrafPtr) 0) {    /* BYU */
  360.             strncpy(RGMwind[dnum]->name,&RGMwind[dnum]->name[1],255);    /* BYU */
  361.             setwtitle(RGMwind[dnum]->wind,RGMwind[dnum]->name);            /* BYU */
  362.         }                            /* BYU */
  363.     }                                /* BYU */
  364.     return(0);                        /* BYU */
  365. }
  366.  
  367. int RGfindbywind
  368.   (
  369.     GrafPtr wind
  370.   )
  371. {
  372. int i = 0;
  373.  
  374.     while ((i < MAXWIND) && ((!RGMwind[i]->inuse) || (RGMwind[i]->wind != wind)))
  375.         i++;
  376.     if (i >= MAXWIND) return(-1);
  377.     return(i);
  378. }
  379.  
  380. int RGupdate
  381.   (
  382.     GrafPtr wind
  383.   )
  384. {
  385. int    i = 0,done;
  386.  
  387.     if ((i = RGfindbywind(wind)) < 0)
  388.         return(-1);
  389.  
  390.     SetPort(wind);
  391.     BeginUpdate(wind);
  392.  
  393.     VGstopred(RGMwind[i]->vg);
  394.     VGpage(RGMwind[i]->vg);
  395.     done = VGpred(RGMwind[i]->vg,RGMwind[i]->vg);
  396.     EndUpdate(wind);
  397.     if (!done)
  398.         netputevent(1,128,RGMwind[i]->vg);
  399.     return(done);
  400. }
  401.  
  402. int RGsupdate
  403.   (
  404.     int i
  405.   )
  406. {
  407. int rg;
  408.  
  409.     rg = RGfindbyVG(i);
  410.  
  411.     if (rg < 0) return(0);
  412.     SetPort(RGMwind[rg]->wind);
  413.     if (!VGpred(RGMwind[rg]->vg,RGMwind[rg]->vg))
  414.     {
  415.         netputevent(1,128,i);
  416.     }
  417.     else
  418.         return(1);
  419.     return(0);
  420. }
  421.  
  422. int RGgetVG
  423.   (
  424.     GrafPtr wind
  425.   )
  426. {
  427. int i;
  428.  
  429.     i = RGfindbywind(wind);
  430.  
  431.     return(RGMwind[i]->vg);
  432. }
  433.  
  434. int RGgetdnum
  435.   (
  436.     GrafPtr wind
  437.   )
  438. {
  439.     return(RGfindbywind(wind));
  440. }
  441.  
  442. int RGgetVS
  443.   (
  444.     int dnum
  445.   )
  446. {
  447.     return(RGMwind[dnum]->vs);
  448. }
  449.  
  450. inSplash(p1, p2)
  451. Point *p1,*p2;
  452. {
  453.     if ((p1->h - p2->h > 3) || (p2->h - p1->h > 3))
  454.         return(0);
  455.     if ((p1->v - p2->v > 3) || (p2->v - p1->v > 3))
  456.         return(0);
  457.  
  458.     return(1);
  459. }
  460.  
  461. long *Ticks = (long *) 0x16a;
  462.  
  463. void VidSync
  464.   (
  465.     void
  466.   )
  467. {
  468. long    a;
  469.  
  470.     a = *Ticks;
  471.     while (a == *Ticks);
  472. }
  473.  
  474. /*
  475.     Resize the tek window. It will always be sqare.
  476. */
  477.  
  478. void RGsize (GrafPtr wind, Point * where)
  479. {
  480.     union {
  481.         Point pt;
  482.         long lg;
  483.     } size;
  484.     Rect SizRect;
  485.     int i;
  486.     
  487.     if ((i = RGfindbywind(wind)) < 0)
  488.         return;
  489.         
  490.     SetRect(&SizRect, 48, 48, 2000,2000);
  491.     
  492.     if (where)
  493.       {                            /* grow icon actions */
  494.         size.lg = growwindow(wind, (Point *) where, &SizRect);
  495.         if ((long) size.lg != 0L)
  496.             {
  497.             if (size.pt.h > size.pt.v)
  498.                 size.pt.h = size.pt.v;
  499.             else
  500.                 size.pt.v = size.pt.h;
  501.                 
  502.             if ((long) size.lg)
  503.                 {
  504.                 SizeWindow(wind, size.pt.h, size.pt.v, FALSE);
  505.                 RGMwind[i]->width   = size.pt.h;             
  506.                 RGMwind[i]->height  = size.pt.h;
  507.                 SetPort (wind);
  508.                 InvalRect(&wind->portRect);    /* Don't forget to redraw */ 
  509.                 }
  510.             }
  511.         else
  512.             return;                            /* user skipped growing */
  513.       }
  514.  
  515. }
  516.  
  517. void RGmousedown
  518.   (
  519.     GrafPtr wind,
  520.     Point *wherein
  521.   )
  522. {
  523. long    lx,ly;
  524. char    thispaceforent[6];
  525. int        i;
  526. Point    where;
  527. char    dum[32];
  528.  
  529.     where = *wherein;
  530.     if ((i = RGfindbywind(wind)) < 0)
  531.         return;
  532.  
  533.     if (!RGMwind[i]->ingin)
  534.     {
  535.     Point    anchor,current,last;
  536. #ifndef MPW
  537.     long    TickCount();
  538. #endif MPW
  539.     long    tc;
  540.     int        x0,y0,x1,y1;
  541.     Rect    rect;
  542.     
  543.         SetPort(wind);
  544.     
  545.         last  = where;
  546.         current = where;
  547.         anchor = where;
  548.     
  549.         PenPat((ConstPatternParam)qd.gray);    
  550.         PenMode(patXor);
  551.     
  552.         SetRect(&rect,0,0,0,0);
  553.     
  554.         while (StillDown())
  555.         {
  556.             GetMouse(¤t);
  557.             if (inSplash(¤t,&anchor)) continue;
  558.             
  559.             if ((current.h - anchor.h)*4 < 3*(current.v - anchor.v))    /* tlr */
  560.                 current.h = (anchor.h + (current.v - anchor.v))*4/3;
  561.             else
  562.                 current.v = (anchor.v + (current.h - anchor.h))*3/4;
  563.                 
  564.             tc = TickCount();
  565.             while(TickCount() == tc);
  566.             VidSync();
  567.             FrameRect(&rect);
  568.     
  569.             if (anchor.v < current.v)
  570.             {
  571.                 rect.top = anchor.v;
  572.                 rect.bottom = current.v;
  573.             }
  574.             else
  575.             {
  576.                 rect.top = current.v;
  577.                 rect.bottom = anchor.v;
  578.             }
  579.     
  580.             if (anchor.h < current.h)
  581.             {
  582.                 rect.left = anchor.h;
  583.                 rect.right = current.h;
  584.             }
  585.             else
  586.             {
  587.                 rect.right = anchor.h;
  588.                 rect.left = current.h;
  589.             }
  590.             
  591.             FrameRect(&rect);
  592.             last = current;
  593.         }
  594.     
  595.         FrameRect(&rect);
  596.  
  597.         PenPat(qd.black);    
  598.         PenMode(patCopy);
  599.  
  600.         if (!inSplash(&anchor,¤t))
  601.         {
  602.             x0 = (int) ((long) rect.left * RGMwind[i]->xscale / RGMwind[i]->width );
  603.             y0 = (int) (RGMwind[i]->yscale -
  604.                     (long) rect.top * RGMwind[i]->yscale / RGMwind[i]->height);
  605.             x1 = (int) ((long) rect.right * RGMwind[i]->xscale / RGMwind[i]->width);
  606.             y1 = (int) (RGMwind[i]->yscale -
  607.                     (long) rect.bottom * RGMwind[i]->yscale / RGMwind[i]->height);
  608.             x1 = (x1 < x0+2) ? x0 + 4 : x1;
  609.             y0 = (y0 < y1+2) ? y1 + 4 : y0;
  610.  
  611.             VGzoom( i,
  612.                     x0 + RGMwind[i]->xorigin,
  613.                     y1 + RGMwind[i]->yorigin,
  614.                     x1 + RGMwind[i]->xorigin,
  615.                     y0 + RGMwind[i]->yorigin);
  616.  
  617.             VGpage(RGMwind[i]->vg);
  618.  
  619.             RGMwind[i]->xscale  = x1 - x0;
  620.             RGMwind[i]->yscale  = y0 - y1;
  621.             RGMwind[i]->xorigin = x0 + RGMwind[i]->xorigin;
  622.             RGMwind[i]->yorigin = y1 + RGMwind[i]->yorigin;
  623.  
  624.             while(!VGpred(RGMwind[i]->vg,RGMwind[i]->vg))
  625.                 Stask();
  626.             RGMlastclick = 0L;
  627.         }
  628.         else
  629.         {
  630.             if (RGMlastclick && ((RGMlastclick + GetDblTime()) > TickCount()))
  631.             {
  632.                 RGMwind[i]->xscale  = WINXMAX;    /* BYU 2.4.7 - added the "W" */
  633.                 RGMwind[i]->yscale  = WINYMAX;    /* BYU 2.4.7 - added the "W" */
  634.                 RGMwind[i]->xorigin = 0;
  635.                 RGMwind[i]->yorigin = 0;
  636.  
  637.                 VGzoom(i,0,0,WINXMAX-1,WINYMAX-1);    /* BYU 2.4.7 - added the "W" */
  638.                 VGpage( RGMwind[i]->vg);
  639.                 while(!VGpred(RGMwind[i]->vg,RGMwind[i]->vg))
  640.                     Stask();
  641.                 RGMlastclick = 0L;
  642.             }
  643.             else RGMlastclick = TickCount();
  644.         }
  645.         return;
  646.     
  647.     }
  648.  
  649.     lx = (RGMwind[i]->xscale * where.h) / ((long) RGMwind[i]->width);
  650.     ly = RGMwind[i]->yscale -
  651.         ((RGMwind[i]->yscale * where.v) / ((long) RGMwind[i]->height));
  652.  
  653.     VGgindata(RGMwind[i]->vg,(int) lx,(int) ly,' ',thispaceforent);
  654.  
  655. sprintf(dum,"GIN i: %d, vs: %d\n",i,RGMwind[i]->vs);
  656. putln(dum);
  657.  
  658.     RSsendstring(RGMwind[i]->vs,thispaceforent,5);
  659.     sprintf(dum," \r\n");
  660.     RSsendstring(RGMwind[i]->vs,dum,3);
  661.     
  662.  
  663.     /*    RGMwind[i]->ingin = 0; */
  664.     unsetgraphcurs();
  665.     RGMlastclick = TickCount();
  666. }
  667.  
  668. void RGMgetrect
  669.   (
  670.       int src,
  671.     Rect * inRect
  672.   )
  673. {
  674.     inRect->top = 0;
  675.     inRect->left = 0;
  676.     inRect->bottom = RGMwind[src]->height;
  677.     inRect->right = RGMwind[src]->width;
  678.     return;
  679. }
  680.